Skip Headers

Oracle® Database SQL Quick Reference 10g Release 2 (10.2) Part Number B14195-02 |
Home | Book List | Contents | Index | Master Index | Feedback

Previous | Next
| View PDF

# 1 SQL Statements

This chapter presents the syntax for Oracle SQL statements.

This chapter includes the following section:

- Syntax for SQL Statements

## Syntax for SQL Statements

SQL statements are the means by which programs and users access data in an Oracle database.

The sections that follow show each SQL statement and its related syntax. Refer to Chapter 5, "Subclauses" for the syntax of the subclauses listed in the syntax for the statements.

See Also: Oracle Database SQL Reference for detailed information about Oracle SQL

ALTER CLUSTER

    ALTER CLUSTER [ schema. ]cluster
      { physical_attributes_clause
      | SIZE size_clause
      | allocate_extent_clause
      | deallocate_unused_clause
      | { CACHE | NOCACHE }
      }
        [ physical_attributes_clause
        | SIZE size_clause
        | allocate_extent_clause
        | deallocate_unused_clause
        | { CACHE | NOCACHE }
        ]...
      [ parallel_clause ] ;

ALTER DATABASE

    ALTER DATABASE [ database ]
      { startup_clauses
      | recovery_clauses
      | database_file_clauses
      | logfile_clauses
      | controlfile_clauses
      | standby_database_clauses
      | default_settings_clauses
      | instance_clauses
      | security_clause
      } ;

ALTER DIMENSION

    ALTER DIMENSION [ schema. ]dimension
      { ADD
        { level_clause
        | hierarchy_clause
        | attribute_clause
        | extended_attribute_clause
        }
        [ ADD
          { level_clause
          | hierarchy_clause
          | attribute_clause
          | extended_attribute_clause
          }
        ]...
      | DROP
        { LEVEL level
            [ RESTRICT | CASCADE ]
        | HIERARCHY hierarchy
        | ATTRIBUTE attribute
            [ LEVEL level [ COLUMN column
                            [, COLUMN column ]... ]
        }
        [ DROP
          { LEVEL level
              [ RESTRICT | CASCADE ]
          | HIERARCHY hierarchy
          | ATTRIBUTE attribute
              [ LEVEL level [ COLUMN column
                              [, COLUMN column ]... ]
          }
        ]...
      | COMPILE
      } ;

ALTER DISKGROUP

    ALTER DISKGROUP
        { diskgroup_name
            { add_disk_clause | drop_disk_clause }
                [, { add_disk_clause | drop_disk_clause } ]...
            | resize_disk_clauses
            } [ rebalance_diskgroup_clause ]
            | {rebalance_diskgroup_clause
              | check_diskgroup_clause
              | diskgroup_template_clauses
              | diskgroup_directory_clauses
              | diskgroup_alias_clauses
              | drop_diskgroup_file_clause
              }
        | { diskgroup_name
              [, diskgroup_name ]...
          | ALL
          }
          { undrop_disk_clause
          | diskgroup_availability
          }
        }

ALTER FUNCTION

    ALTER FUNCTION [ schema. ]function
      COMPILE [ DEBUG ]
      [ compiler_parameters_clause
        [ compiler_parameters_clause ] ... ]
      [ REUSE SETTINGS ] ;

ALTER INDEX

    ALTER INDEX [ schema. ]index
      { { deallocate_unused_clause
        | allocate_extent_clause
        | shrink_clause
        | parallel_clause
        | physical_attributes_clause
        | logging_clause
        }
          [ deallocate_unused_clause
          | allocate_extent_clause
          | shrink_clause
          | parallel_clause
          | physical_attributes_clause
          | logging_clause
          ]...
      | rebuild_clause
      | PARAMETERS ('ODCI_parameters')
      | { ENABLE | DISABLE }
      | UNUSABLE
      | RENAME TO new_name
      | COALESCE
      | { MONITORING | NOMONITORING } USAGE
      | UPDATE BLOCK REFERENCES
      | alter_index_partitioning
      } ;

ALTER INDEXTYPE

    ALTER INDEXTYPE [ schema. ]indextype
      { { ADD | DROP }
        [ schema. ]operator (parameter_types)
          [, { ADD | DROP }
              [ schema. ]operator (parameter_types)
          ]...
        [ using_type_clause ]
      | COMPILE
      } ;

ALTER JAVA

    ALTER JAVA
      { SOURCE | CLASS } [ schema. ]object_name
      [ RESOLVER
          ( ( match_string [, ] { schema_name | - } )
            [ ( match_string [, ] { schema_name | - } )
            ]...
          )
      ]
      { { COMPILE | RESOLVE }
      | invoker_rights_clause
      } ;

ALTER MATERIALIZED VIEW

    ALTER MATERIALIZED VIEW
      [ schema. ](materialized_view)
      [ physical_attributes_clause
      | table_compression
      | LOB_storage_clause
        [, LOB_storage_clause ]...
      | modify_LOB_storage_clause
        [, modify_LOB_storage_clause ]...
      | alter_table_partitioning
      | parallel_clause
      | logging_clause
      | allocate_extent_clause
      | shrink_clause
      | { CACHE | NOCACHE }
      ]
      [ alter_iot_clauses ]
      [ USING INDEX physical_attributes_clause ]
      [ MODIFY scoped_table_ref_constraint
      | alter_mv_refresh
      ]
      [ { ENABLE | DISABLE } QUERY REWRITE
      | COMPILE
      | CONSIDER FRESH
      ] ;

ALTER MATERIALIZED VIEW LOG

    ALTER MATERIALIZED VIEW LOG [ FORCE ]
      ON [ schema. ]table
      [ physical_attributes_clause
      | alter_table_partitioning
      | parallel_clause
      | logging_clause
      | allocate_extent_clause
      | shrink_clause
      | { CACHE | NOCACHE }
      ]
      [ ADD
          { { OBJECT ID
            | PRIMARY KEY
            | ROWID
            | SEQUENCE
            }
            [ (column [, column ]...) ]
          | (column [, column ]... )
          }
            [, { { OBJECT ID
                 | PRIMARY KEY
                 | ROWID
                 | SEQUENCE
                 }
                 [ (column [, column ]...) ]
               | (column [, column ]...)
               }
            ]...
          [ new_values_clause ]
      ] ;

ALTER OPERATOR

    ALTER OPERATOR [ schema. ]operator
      { add_binding_clause
      | drop_binding_clause
      | COMPILE
      } ;

ALTER OUTLINE

    ALTER OUTLINE
      [ PUBLIC | PRIVATE ] outline
      { REBUILD
      | RENAME TO new_outline_name
      | CHANGE CATEGORY TO new_category_name
      | { ENABLE | DISABLE }
      }
        [ REBUILD
        | RENAME TO new_outline_name
        | CHANGE CATEGORY TO new_category_name
        | { ENABLE | DISABLE }
        ]... ;

ALTER PACKAGE

    ALTER PACKAGE [ schema. ]package
      COMPILE [ DEBUG ]
      [ PACKAGE | SPECIFICATION | BODY ]
      [ compiler_parameters_clause
        [ compiler_parameters_clause ] ... ]
      [ REUSE SETTINGS ] ;

ALTER PROCEDURE

    ALTER PROCEDURE [ schema. ]procedure
      COMPILE [ DEBUG ]
      [ compiler_parameters_clause
        [ compiler_parameters_clause ] ... ]
      [ REUSE SETTINGS ] ;

ALTER PROFILE

    ALTER PROFILE profile LIMIT
      { resource_parameters | password_parameters }
        [ resource_parameters | password_parameters
        ]... ;

ALTER RESOURCE COST

    ALTER RESOURCE COST
      { CPU_PER_SESSION
      | CONNECT_TIME
      | LOGICAL_READS_PER_SESSION
      | PRIVATE_SGA
      }
      integer
        [ { CPU_PER_SESSION
          | CONNECT_TIME
          | LOGICAL_READS_PER_SESSION
          | PRIVATE_SGA
          }
          integer
        ] ... ;

ALTER ROLE

    ALTER ROLE role
      { NOT IDENTIFIED
      | IDENTIFIED
          { BY password
          | USING [ schema. ]package
          | EXTERNALLY
          | GLOBALLY
          }
      } ;

ALTER ROLLBACK SEGMENT

    ALTER ROLLBACK SEGMENT rollback_segment
      { ONLINE
      | OFFLINE
      | storage_clause
      | SHRINK [ TO size_clause ]
      };

ALTER SEQUENCE

    ALTER SEQUENCE [ schema. ]sequence
      { INCREMENT BY integer
      | { MAXVALUE integer | NOMAXVALUE }
      | { MINVALUE integer | NOMINVALUE }
      | { CYCLE | NOCYCLE }
      | { CACHE integer | NOCACHE }
      | { ORDER | NOORDER }
      }
        [ INCREMENT BY integer
        | { MAXVALUE integer | NOMAXVALUE }
        | { MINVALUE integer | NOMINVALUE }
        | { CYCLE | NOCYCLE }
        | { CACHE integer | NOCACHE }
        | { ORDER | NOORDER }
        ]... ;

ALTER SESSION

    ALTER SESSION
      { ADVISE { COMMIT | ROLLBACK | NOTHING }
      | CLOSE DATABASE LINK dblink
      | { ENABLE | DISABLE } COMMIT IN PROCEDURE
      | { ENABLE | DISABLE } GUARD
      | { ENABLE | DISABLE | FORCE } PARALLEL
        { DML | DDL | QUERY } [ PARALLEL integer ]
      | { ENABLE RESUMABLE
          [ TIMEOUT integer ] [ NAME string ]
        | DISABLE RESUMABLE
        }
      | alter_session_set_clause
      } ;

ALTER SYSTEM

    ALTER SYSTEM
      { archive_log_clause
      | checkpoint_clause
      | check_datafiles_clause
      | distributed_recov_clauses
      | FLUSH { SHARED_POOL | BUFFER_CACHE }
      | end_session_clauses
      | SWITCH LOGFILE
      | { SUSPEND | RESUME }
      | quiesce_clauses
      | alter_system_security_clauses
      | shutdown_dispatcher_clause
      | REGISTER
      | SET alter_system_set_clause
            [ alter_system_set_clause ]...
      | RESET alter_system_reset_clause
              [ alter_system_reset_clause ]...
      } ;

ALTER TABLE

    ALTER TABLE [ schema. ]table
      [ alter_table_properties
      | column_clauses
      | constraint_clauses
      | alter_table_partitioning
      | alter_external_table_clauses
      | move_table_clause
      ]
      [ enable_disable_clause
      | { ENABLE | DISABLE }
        { TABLE LOCK | ALL TRIGGERS }
        [ enable_disable_clause
        | { ENABLE | DISABLE }
          { TABLE LOCK | ALL TRIGGERS }
        ]...
      ] ;

ALTER TABLESPACE

    ALTER TABLESPACE tablespace
      { DEFAULT
          [ table_compression ] storage_clause
      | MINIMUM EXTENT size_clause
      | RESIZE size_clause
      | COALESCE
      | RENAME TO new_tablespace_name
      | { BEGIN | END } BACKUP
      | datafile_tempfile_clauses
      | tablespace_logging_clauses
      | tablespace_group_clause
      | tablespace_state_clauses
      | autoextend_clause
      | flashback_mode_clause
      | tablespace_retention_clause
      } ;

ALTER TRIGGER

    ALTER TRIGGER [ schema. ]trigger
      { ENABLE
      | DISABLE
      | RENAME TO new_name
      | COMPILE [ DEBUG ]
          [ compiler_parameters_clause
            [ compiler_parameters_clause ] ... ]
          [ REUSE SETTINGS ]
      } ;

ALTER TYPE

    ALTER TYPE [ schema. ]type
      { compile_type_clause
      | replace_type_clause
      | { alter_method_spec
        | alter_attribute_definition
        | alter_collection_clauses
        | [ NOT ] { INSTANTIABLE | FINAL }
        }
        [ dependent_handling_clause ]
      } ;

ALTER USER

    ALTER USER
      { user
        { IDENTIFIED
          { BY password [ REPLACE old_password ]
          | EXTERNALLY [ AS 'certificate_DN' ]
          | GLOBALLY [ AS '[directory_DN]' ]
          }
        | DEFAULT TABLESPACE tablespace
        | TEMPORARY TABLESPACE
             { tablespace | tablespace_group_name }
        | QUOTA { size_clause
                | UNLIMITED
                } ON tablespace
          [ QUOTA { size_clause
                  | UNLIMITED
                  } ON tablespace
          ]...
        | PROFILE profile
        | DEFAULT ROLE { role [, role ]...
                       | ALL [ EXCEPT
                                role [, role ]... ]
                       | NONE
                       }
        | PASSWORD EXPIRE
        | ACCOUNT { LOCK | UNLOCK }
        }
          [  { IDENTIFIED
               { BY password [ REPLACE old_password ]
               | EXTERNALLY [ AS 'certificate_DN' ]
               | GLOBALLY [ AS '[directory_DN]' ]
               }
             | DEFAULT TABLESPACE tablespace
             | TEMPORARY TABLESPACE
                  { tablespace | tablespace_group_name }
             | QUOTA { size_clause
                     | UNLIMITED
                     } ON tablespace
               [ QUOTA { size_clause
                       | UNLIMITED
                       } ON tablespace
               ]...
             | PROFILE profile
             | DEFAULT ROLE { role [, role ]...
                            | ALL [ EXCEPT
                                     role [, role ]... ]
                            | NONE
                            }
             | PASSWORD EXPIRE
             | ACCOUNT { LOCK | UNLOCK }
             }
          ]...
      | user [, user ]...
        proxy_clause ;

ALTER VIEW

    ALTER VIEW [ schema. ]view
      { ADD out_of_line_constraint
      | MODIFY CONSTRAINT constraint
          { RELY | NORELY }
      | DROP { CONSTRAINT constraint
             | PRIMARY KEY
             | UNIQUE (column [, column ]...)
             }
      | COMPILE
      } ;

ANALYZE

    ANALYZE
      { TABLE [ schema. ]table
          [ PARTITION (partition)
          | SUBPARTITION (subpartition)
          ]
      | INDEX [ schema. ]index
          [ PARTITION (partition)
          | SUBPARTITION (subpartition)
          ]
      | CLUSTER [ schema. ]cluster
      }
      { validation_clauses
      | LIST CHAINED ROWS [ into_clause ]
      | DELETE [ SYSTEM ] STATISTICS
      | compute_statistics_clause
      | estimate_statistics_clause
      } ;

ASSOCIATE STATISTICS

    ASSOCIATE STATISTICS WITH
      { column_association | function_association } ;

AUDIT

    AUDIT
      { sql_statement_clause | schema_object_clause | NETWORK }
      [ BY { SESSION | ACCESS } ]
      [ WHENEVER [ NOT ] SUCCESSFUL ] ;

CALL

    CALL
      { routine_clause
      | object_access_expression
      }
      [ INTO :host_variable
        [ [ INDICATOR ] :indicator_variable ] ] ;

COMMENT

    COMMENT ON
      { TABLE [ schema. ]
        { table | view }
      | COLUMN [ schema. ]
        { table. | view. | materialized_view. } column
      | OPERATOR [ schema. ] operator
      | INDEXTYPE [ schema. ] indextype
      | MATERIALIZED VIEW materialized_view
      }
      IS string ;

COMMIT

    COMMIT [ WORK ]
      [
        [ COMMENT string ]
        | [ WRITE
            [ IMMEDIATE | BATCH ] [ WAIT | NOWAIT ]
        ]
      | FORCE string [, integer ]
      ] ;

CREATE CLUSTER

    CREATE CLUSTER [ schema. ]cluster
      (column datatype [ SORT ]
        [, column datatype [ SORT ] ]...
      )
      [ { physical_attributes_clause
        | SIZE size_clause
        | TABLESPACE tablespace
        | { INDEX
          | [ SINGLE TABLE ]
            HASHKEYS integer [ HASH IS expr ]
          }
        }
          [ physical_attributes_clause
          | SIZE size_clause
          | TABLESPACE tablespace
          | { INDEX
            | [ SINGLE TABLE ]
              HASHKEYS integer [ HASH IS expr ]
            }
          ]...
      ]
      [ parallel_clause ]
      [ NOROWDEPENDENCIES | ROWDEPENDENCIES ]
      [ CACHE | NOCACHE ] ;

CREATE CONTEXT

    CREATE [ OR REPLACE ] CONTEXT namespace
      USING [ schema. ] package
      [ INITIALIZED { EXTERNALLY | GLOBALLY }
      | ACCESSED GLOBALLY
      ] ;

CREATE CONTROLFILE

    CREATE CONTROLFILE
      [ REUSE ]
      [ SET ]
      DATABASE database
      [ logfile_clause ]
      { RESETLOGS | NORESETLOGS }
      [ DATAFILE file_specification
                 [, file_specification ]... ]
      [ { MAXLOGFILES integer
        | MAXLOGMEMBERS integer
        | MAXLOGHISTORY integer
        | MAXDATAFILES integer
        | MAXINSTANCES integer
        | { ARCHIVELOG | NOARCHIVELOG }
        | FORCE LOGGING
        }
          [ MAXLOGFILES integer
          | MAXLOGMEMBERS integer
          | MAXLOGHISTORY integer
          | MAXDATAFILES integer
          | MAXINSTANCES integer
          | { ARCHIVELOG | NOARCHIVELOG }
          | FORCE LOGGING
          ]...
      ]
      [ character_set_clause ] ;

CREATE DATABASE

    CREATE DATABASE [ database ]
      { USER SYS IDENTIFIED BY password
      | USER SYSTEM IDENTIFIED BY password
      | CONTROLFILE REUSE
      | MAXDATAFILES integer
      | MAXINSTANCES integer
      | CHARACTER SET charset
      | NATIONAL CHARACTER SET charset
      | SET DEFAULT
          { BIGFILE | SMALLFILE } TABLESPACE
      | database_logging_clauses
      | tablespace_clauses
      | set_time_zone_clause
      }... ;

CREATE DATABASE LINK

    CREATE [ SHARED ] [ PUBLIC ] DATABASE LINK dblink
      [ CONNECT TO
        { CURRENT_USER
        | user IDENTIFIED BY password [ dblink_authentication ]
        }
      | dblink_authentication
      ]
        [ CONNECT TO
          { CURRENT_USER
          | user IDENTIFIED BY password [ dblink_authentication ]
          }
        | dblink_authentication
        ]...
      [ USING connect_string ] ;

CREATE DIMENSION

    CREATE DIMENSION [ schema. ]dimension
      level_clause
      [ level_clause ]...
      { hierarchy_clause
      | attribute_clause
      | extended_attribute_clause
      }
        [ hierarchy_clause
        | attribute_clause
        | extended_attribute_clause
        ]... ;

CREATE DIRECTORY

    CREATE [ OR REPLACE ] DIRECTORY directory
      AS 'path_name' ;

CREATE DISKGROUP

    CREATE DISKGROUP diskgroup_name
      [ { HIGH | NORMAL | EXTERNAL } REDUNDANCY ]
      [ FAILGROUP failgroup_name ]
      DISK qualified_disk_clause
           [, qualified_disk_clause ]...
        [ [ FAILGROUP failgroup_name ]
          DISK qualified_disk_clause
               [, qualified_disk_clause ]...
        ]... ;

CREATE FUNCTION

    CREATE [ OR REPLACE ] FUNCTION [ schema. ]function
      [ (argument [ IN | OUT | IN OUT ]
         [ NOCOPY ] datatype
           [, argument [ IN | OUT | IN OUT ]
              [ NOCOPY ] datatype
           ]...
        )
      ]
      RETURN datatype
      [ { invoker_rights_clause
        | DETERMINISTIC
        | parallel_enable_clause
        }
          [ invoker_rights_clause
          | DETERMINISTIC
          | parallel_enable_clause
          ]...
      ]
      { { AGGREGATE | PIPELINED }
        USING [ schema. ]implementation_type
      | [ PIPELINED ]
        { IS | AS }
        { pl/sql_function_body | call_spec }
      } ;

CREATE INDEX

    CREATE [ UNIQUE | BITMAP ] INDEX [ schema. ]index
      ON { cluster_index_clause
         | table_index_clause
         | bitmap_join_index_clause
         } ;

CREATE INDEXTYPE

    CREATE [ OR REPLACE ] INDEXTYPE
      [ schema. ]indextype FOR
      [ schema. ]operator (paramater_type
                           [, paramater_type ]...)
        [, [ schema. ]operator (paramater_type
                                [, paramater_type ]...)
        ]...
      using_type_clause ;

CREATE JAVA

    CREATE [ OR REPLACE ]
      [ AND { RESOLVE | COMPILE } ]
      [ NOFORCE ]
      JAVA { { SOURCE | RESOURCE }
             NAMED [ schema. ]primary_name
           | CLASS [ SCHEMA schema ]
           }
      [ invoker_rights_clause ]
      [ RESOLVER
        ((match_string [,] { schema_name | - })
          [ (match_string [,] { schema_name | - }) ]...
        )
      ]
      { USING { BFILE (directory_object_name ,
                       server_file_name)
              | { CLOB | BLOB | BFILE }
                subquery
              | 'key_for_BLOB'
              }
      | AS source_char
      }

CREATE LIBRARY

    CREATE [ OR REPLACE ] LIBRARY [ schema. ]libname
      { IS | AS } 'filename' [ AGENT 'agent_dblink' ] ;

CREATE MATERIALIZED VIEW

    CREATE MATERIALIZED VIEW
      [ schema. ]materialized_view
      [ column_alias [, column_alias]... ]
      [ OF [ schema. ]object_type ]
      [ (scoped_table_ref_constraint) ]
      { ON PREBUILT TABLE
        [ { WITH | WITHOUT } REDUCED PRECISION ]
      | physical_properties materialized_view_props
      }
      [ USING INDEX
        [ physical_attributes_clause
        | TABLESPACE tablespace
        ]
          [ physical_attributes_clause
          | TABLESPACE tablespace
          ]...
      | USING NO INDEX
      ]
      [ create_mv_refresh ]
      [ FOR UPDATE ]
      [ { DISABLE | ENABLE }
        QUERY REWRITE
      ]
      AS subquery ;

CREATE MATERIALIZED VIEW LOG

    CREATE MATERIALIZED VIEW LOG
      ON [ schema. ] table
      [ physical_attributes_clause
      | TABLESPACE tablespace
      | logging_clause
      | { CACHE | NOCACHE }
        [ physical_attributes_clause
        | TABLESPACE tablespace
        | logging_clause
        | { CACHE | NOCACHE }
        ]...
      ]
      [ parallel_clause ]
      [ table_partitioning_clauses ]
      [ WITH { OBJECT ID
             | PRIMARY KEY
             | ROWID
             | SEQUENCE
             | (column [, column ]...)
             }
               [, { OBJECT ID
                  | PRIMARY KEY
                  | ROWID
                  | SEQUENCE
                  | (column [, column ]...)
                  }
               ]...
        [ new_values_clause ]
      ] ;

CREATE OPERATOR

    CREATE [ OR REPLACE ] OPERATOR
       [ schema. ] operator binding_clause ;

CREATE OUTLINE

    CREATE [ OR REPLACE ]
       [ PUBLIC | PRIVATE ] OUTLINE [ outline ]
       [ FROM [ PUBLIC | PRIVATE ] source_outline ]
       [ FOR CATEGORY category ]
       [ ON statement ] ;

CREATE PACKAGE

    CREATE [ OR REPLACE ] PACKAGE [ schema. ]package
       [ invoker_rights_clause ]
       { IS | AS } pl/sql_package_spec ;

CREATE PACKAGE BODY

    CREATE [ OR REPLACE ] PACKAGE BODY
       [ schema. ]package
       { IS | AS } pl/sql_package_body ;

CREATE PFILE

    CREATE PFILE [= 'pfile_name' ]
       FROM SPFILE [= 'spfile_name'] ;

CREATE PROCEDURE

    CREATE [ OR REPLACE ] PROCEDURE [ schema. ]procedure
       [ (argument [ { IN | OUT | IN OUT } ]
                   [ NOCOPY ]
                   datatype [ DEFAULT expr ]
           [, argument [ { IN | OUT | IN OUT } ]
                       [ NOCOPY ]
                       datatype [ DEFAULT expr ]
           ]...
         )
       ]
       [ invoker_rights_clause ]
       { IS | AS }
       { pl/sql_subprogram_body | call_spec } ;

CREATE PROFILE

    CREATE PROFILE profile
       LIMIT { resource_parameters
             | password_parameters
             }
               [ resource_parameters
               | password_parameters
               ]... ;

CREATE RESTORE POINT

    CREATE RESTORE POINT restore_point
       [ GUARANTEE FLASHBACK DATABASE ];

CREATE ROLE

    CREATE ROLE role
       [ NOT IDENTIFIED
       | IDENTIFIED { BY password
                    | USING [ schema. ] package
                    | EXTERNALLY
                    | GLOBALLY
                    }
       ] ;

CREATE ROLLBACK SEGMENT

    CREATE [ PUBLIC ] ROLLBACK SEGMENT rollback_segment
      [ { TABLESPACE tablespace | storage_clause }
          [ TABLESPACE tablespace | storage_clause ]...
      ];

CREATE SCHEMA

    CREATE SCHEMA AUTHORIZATION schema
       { create_table_statement
       | create_view_statement
       | grant_statement
       }
         [ create_table_statement
         | create_view_statement
         | grant_statement
         ]... ;

CREATE SEQUENCE

    CREATE SEQUENCE [ schema. ]sequence
       [ { INCREMENT BY | START WITH } integer
       | { MAXVALUE integer | NOMAXVALUE }
       | { MINVALUE integer | NOMINVALUE }
       | { CYCLE | NOCYCLE }
       | { CACHE integer | NOCACHE }
       | { ORDER | NOORDER }
       ]
         [ { INCREMENT BY | START WITH } integer
         | { MAXVALUE integer | NOMAXVALUE }
         | { MINVALUE integer | NOMINVALUE }
         | { CYCLE | NOCYCLE }
         | { CACHE integer | NOCACHE }
         | { ORDER | NOORDER }
         ]... ;

CREATE SPFILE

    CREATE SPFILE [= 'spfile_name' ]
      FROM PFILE [= 'pfile_name' ] ;

CREATE SYNONYM

    CREATE [ OR REPLACE ] [ PUBLIC ] SYNONYM
       [ schema. ]synonym
       FOR [ schema. ]object [ @ dblink ] ;

CREATE TABLE

    { relational_table | object_table | XMLType_table }

CREATE TABLESPACE

    CREATE
       [ BIGFILE | SMALLFILE ]
       { permanent_tablespace_clause
       | temporary_tablespace_clause
       | undo_tablespace_clause
       } ;

CREATE TRIGGER

    CREATE [ OR REPLACE ] TRIGGER [ schema. ]trigger
       { BEFORE | AFTER | INSTEAD OF }
       { dml_event_clause
       | { ddl_event [ OR ddl_event ]...
         | database_event [ OR database_event ]...
         }
         ON { [ schema. ]SCHEMA
            | DATABASE
            }
       }
       [ WHEN (condition) ]
       { pl/sql_block | call_procedure_statement } ;

CREATE TYPE

    { create_incomplete_type
    | create_object_type
    | create_varray_type
    | create_nested_table_type
    }

CREATE TYPE BODY

    CREATE [ OR REPLACE ] TYPE BODY [ schema. ]type_name
       { IS | AS }
       { subprogram_declaration
       | map_order_func_declaration
       }
         [, { subprogram_declaration
            | map_order_func_declaration
            }
         ]...
       END ;

CREATE USER

    CREATE USER user
       IDENTIFIED { BY password
                  | EXTERNALLY [ AS 'certificate_DN' ]
                  | GLOBALLY [ AS '[ directory_DN ]' ]
                  }
       [ DEFAULT TABLESPACE tablespace
       | TEMPORARY TABLESPACE
            { tablespace | tablespace_group_name }
       | QUOTA size_clause
               | UNLIMITED
               }
               ON tablespace
         [ QUOTA size_clause
                 | UNLIMITED
                 }
                 ON tablespace
         ]...
       | PROFILE profile
       | PASSWORD EXPIRE
       | ACCOUNT { LOCK | UNLOCK }
         [ DEFAULT TABLESPACE tablespace
         | TEMPORARY TABLESPACE
              { tablespace | tablespace_group_name }
         | QUOTA size_clause
                 | UNLIMITED
                 }
                 ON tablespace
           [ QUOTA size_clause
                   | UNLIMITED
                   }
                   ON tablespace
           ]...
         | PROFILE profile
         | PASSWORD EXPIRE
         | ACCOUNT { LOCK | UNLOCK }
         ]...
      ] ;

CREATE VIEW

    CREATE [ OR REPLACE ] [ [ NO ] FORCE ] VIEW
       [ schema. ]view
       [ (alias [ inline_constraint
                  [ inline_constraint ]... ]
         | out_of_line_constraint
           [, alias [ inline_constraint
                      [ inline_constraint ]... ]
           | out_of_line_constraint
           ]...
         )
       | object_view_clause
       | XMLType_view_clause
       ]
       AS subquery [ subquery_restriction_clause ] ;

DELETE

    DELETE [ hint ]
       [ FROM ]
       { dml_table_expression_clause
       | ONLY (dml_table_expression_clause)
       }
       [ t_alias ]
       [ where_clause ]
       [ returning_clause ] [error_logging_clause];

DISASSOCIATE STATISTICS

    DISASSOCIATE STATISTICS FROM
       { COLUMNS [ schema. ]table.column
                   [, [ schema. ]table.column ]...
       | FUNCTIONS [ schema. ]function
                     [, [ schema. ]function ]...
       | PACKAGES [ schema. ]package
                    [, [ schema. ]package ]...
       | TYPES [ schema. ]type
                 [, [ schema. ]type ]...
       | INDEXES [ schema. ]index
                   [, [ schema. ]index ]...
       | INDEXTYPES [ schema. ]indextype
                      [, [ schema. ]indextype ]...
       }
       [ FORCE ] ;

DROP CLUSTER

    DROP CLUSTER [ schema. ]cluster
       [ INCLUDING TABLES [ CASCADE CONSTRAINTS ] ] ;

DROP CONTEXT

    DROP CONTEXT namespace ;

DROP DATABASE

    DROP DATABASE ;

DROP DATABASE LINK

    DROP [ PUBLIC ] DATABASE LINK dblink ;

DROP DIMENSION

    DROP DIMENSION [ schema. ]dimension ;

DROP DIRECTORY

    DROP DIRECTORY directory_name ;

DROP DISKGROUP

    DROP DISKGROUP diskgroup_name
       [ { INCLUDING | EXCLUDING }
         CONTENTS
       ] ;

DROP FUNCTION

    DROP FUNCTION [ schema. ]function_name ;

DROP INDEX

    DROP INDEX [ schema. ]index [ FORCE ] ;

DROP INDEXTYPE

    DROP INDEXTYPE [ schema. ]indextype [ FORCE ] ;

DROP JAVA

    DROP JAVA
       { SOURCE | CLASS | RESOURCE }
       [ schema. ]object_name ;

DROP LIBRARY

    DROP LIBRARY library_name ;

DROP MATERIALIZED VIEW

    DROP MATERIALIZED VIEW
       [ schema. ]materialized_view
       [ PRESERVE TABLE ] ;

DROP MATERIALIZED VIEW LOG

    DROP MATERIALIZED VIEW LOG
       ON [ schema. ]table ;

DROP OPERATOR

    DROP OPERATOR [ schema. ]operator [ FORCE ] ;

DROP OUTLINE

    DROP OUTLINE outline ;

DROP PACKAGE

    DROP PACKAGE [ BODY ] [ schema. ]package ;

DROP PROCEDURE

    DROP PROCEDURE [ schema. ]procedure ;

DROP PROFILE

    DROP PROFILE profile [ CASCADE ] ;

DROP RESTORE POINT

    DROP RESTORE POINT restore_point ;

DROP ROLE

    DROP ROLE role ;

DROP ROLLBACK SEGMENT

    DROP ROLLBACK SEGMENT rollback_segment ;

DROP SEQUENCE

    DROP SEQUENCE [ schema. ]sequence_name ;

DROP SYNONYM

    DROP [ PUBLIC ] SYNONYM [ schema. ]synonym
       [ FORCE ] ;

DROP TABLE

    DROP TABLE [ schema. ]table
       [ CASCADE CONSTRAINTS ]
       [ PURGE ] ;

DROP TABLESPACE

    DROP TABLESPACE tablespace
       [ INCLUDING CONTENTS [ {AND | KEEP} DATAFILES ]
         [ CASCADE CONSTRAINTS ]
       ] ;

DROP TRIGGER

    DROP TRIGGER [ schema. ]trigger ;

DROP TYPE

    DROP TYPE [ schema. ]type_name
       [ FORCE | VALIDATE ] ;

DROP TYPE BODY

    DROP TYPE BODY [ schema. ]type_name ;

DROP USER

    DROP USER user [ CASCADE ] ;

DROP VIEW

    DROP VIEW [ schema. ] view
       [ CASCADE CONSTRAINTS ] ;

EXPLAIN PLAN

    EXPLAIN PLAN
       [ SET STATEMENT_ID = string ]
       [ INTO [ schema. ]table [ @ dblink ] ]
       FOR statement ;

FLASHBACK DATABASE

    FLASHBACK [ STANDBY ] DATABASE [ database ]
       { TO { { SCN | TIMESTAMP } expr
            | RESTORE POINT restore_point
            }
       | TO BEFORE { SCN | TIMESTAMP} expr
                   | RESETLOGS
                   }
       };

FLASHBACK TABLE

    FLASHBACK TABLE
       [ schema. ]table
         [, [ schema. ]table ]...
       TO { { SCN | TIMESTAMP } expr
          | RESTORE POINT restore_point
          }
            [ { ENABLE | DISABLE } TRIGGERS ]
          | BEFORE DROP [ RENAME TO table ]
          } ;

GRANT

    GRANT { grant_system_privileges
          | grant_object_privileges
          } ;

INSERT

    INSERT [ hint ]
       { single_table_insert | multi_table_insert } ;

LOCK TABLE

    LOCK TABLE
       [ schema. ] { table | view }
       [ { PARTITION (partition)
         | SUBPARTITION (subpartition)
         }
       | @ dblink
       ]
         [, [ schema. ] { table | view }
            [ { PARTITION (partition)
              | SUBPARTITION (subpartition)
              }
            | @ dblink
            ]
         ]...
       IN lockmode MODE
       [ NOWAIT ] ;

MERGE

    MERGE [ hint ]
       INTO [ schema. ] { table | view } [ t_alias ]
       USING [ schema. ] { table | view | subquery }
         [ t_alias ]
       ON ( condition )
       [ merge_update_clause ]
       [ merge_insert_clause ]
       [ error_logging_clause ] ;

NOAUDIT

    NOAUDIT
       { sql_statement_clause
       | schema_object_clause
       | NETWORK
       }
       [ WHENEVER [ NOT ] SUCCESSFUL ] ;

PURGE

    PURGE
       { { TABLE table
         | INDEX index
         }
       | { RECYCLEBIN | DBA_RECYCLEBIN }
       | TABLESPACE tablespace
         [ USER user ]
       } ;
    DO NOT IMPORT!! Attempting to import locks up FrameMaker completely!

RENAME

    RENAME old_name
       TO new_name ;

REVOKE

    REVOKE { revoke_system_privileges
           | revoke_object_privileges
           } ;

ROLLBACK

    ROLLBACK [ WORK ]
       [ TO [ SAVEPOINT ] savepoint
       | FORCE string
       ] ;

SAVEPOINT

    SAVEPOINT savepoint ;

SELECT

    subquery [ for_update_clause ] ;

SET CONSTRAINT[S]

    SET { CONSTRAINT | CONSTRAINTS }
        { constraint [, constraint ]...
        | ALL
        }
        { IMMEDIATE | DEFERRED } ;

SET ROLE

    SET ROLE
       { role [ IDENTIFIED BY password ]
         [, role [ IDENTIFIED BY password ] ]...
       | ALL [ EXCEPT role [, role ]... ]
       | NONE
       } ;

SET TRANSACTION

    SET TRANSACTION
       { { READ { ONLY | WRITE }
         | ISOLATION LEVEL
           { SERIALIZABLE | READ COMMITTED }
         | USE ROLLBACK SEGMENT rollback_segment
         }
         [ NAME string ]
       | NAME string
       } ;

TRUNCATE

    TRUNCATE
       { TABLE [ schema. ]table
         [ { PRESERVE | PURGE } MATERIALIZED VIEW LOG ]
       | CLUSTER [ schema. ]cluster
       }
       [ { DROP | REUSE } STORAGE ] ;

UPDATE

    UPDATE [ hint ]
       { dml_table_expression_clause
       | ONLY (dml_table_expression_clause)
       }
       [ t_alias ]
       update_set_clause
       [ where_clause ]
       [ returning_clause ] [error_logging_clause] ;